package com.jiangyg.devtools.toolkit;

import com.intellij.ide.util.PackageUtil;
import com.intellij.openapi.module.Module;
import com.intellij.openapi.module.ModuleUtilCore;
import com.intellij.openapi.project.Project;
import com.intellij.openapi.vfs.VirtualFile;
import com.intellij.psi.PsiDirectory;
import org.apache.commons.lang.StringUtils;

import java.io.File;

/**
 * 类描述：常用工具
 *
 * @author jiangyg
 * @version 1.0
 * @date 2023年08月18日
 */
public class CommonUtils {

    /**
     * 功能描述：生成省略字符串
     *
     * @param str 字符串
     * @param len 显示长度
     * @return 字符串
     */
    public static String ellipsisString(String str, int len) {
        if (str == null) {
            return StringUtils.EMPTY;
        }
        if (str.length() <= len) {
            return str;
        }
        return str.substring(0, len) + "...";
    }

    /**
     * 功能描述：获取包路径
     *
     * @param project       项目
     * @param packageString 包
     * @return 包路径
     */
    public static String getPackagePath(Project project, String packageString) {
        // 模块
        final Module module = CommonUtils.findModuleForProject(project);
        // 包地址
        final PsiDirectory directory = PackageUtil.findPossiblePackageDirectoryInModule(module, packageString);
        Assert.notNull(directory);
        // 包目录
        String canonicalPath = directory.getVirtualFile().getCanonicalPath();
        Assert.notNull(canonicalPath);
        // 地址转换
//        final Matcher matcher = Pattern.compile("(.*?)[\\\\|/]*").matcher(canonicalPath);
//        if (matcher.find()) {
//            canonicalPath = matcher.group(1);
//        }
        return canonicalPath + File.separatorChar;
    }

    /**
     * 功能描述：根据工程找模块
     *
     * @param project 功能
     * @return 模块
     */
    public static Module findModuleForProject(Project project) {
        final VirtualFile projectFile = project.getProjectFile();
        Assert.notNull(projectFile);
        return ModuleUtilCore.findModuleForFile(projectFile, project);
    }

    /**
     * 功能描述：简单的判断字符串是否是JSON对象
     *
     * @param str 字符串
     * @return 是否
     */
    public static boolean isJsonObject(String str) {
        return StringUtils.isNotBlank(str) && str.startsWith("{") && str.endsWith("}");
    }

    /**
     * 功能描述：简单的判断字符串是否是JSON数组
     *
     * @param str 字符串
     * @return 是否
     */
    public static boolean isJsonArray(String str) {
        return StringUtils.isNotBlank(str) && str.startsWith("[") && str.endsWith("]");
    }

    /**
     * 功能描述：简单的判断 byte 数组是否是JSON数据
     *
     * @param bytes byte 数组
     * @return 是否
     */
    public static boolean isJsonObject(byte[] bytes) {
        if (bytes == null || bytes.length == 0) {
            return false;
        }
        return findByteNotBlankByBytes(bytes, true) == 123 && findByteNotBlankByBytes(bytes, false) == 125;
    }

    /**
     * 功能描述：从前或者后查询 byte 数组第一个非空的 byte
     *
     * @param bytes byte 数组
     * @param front 从前或者后， true - 从前 ，false - 从后
     * @return byte
     */
    private static byte findByteNotBlankByBytes(byte[] bytes, boolean front) {
        // 从前开始匹配第一个非空格的 byte
        if (front) {
            for (final byte b : bytes) {
                if (b == 9 || b == 13 || b == 32) {
                    continue;
                }
                return b;
            }
            return 32;
        }
        // 从后开始匹配第一个非空格的 byte
        for (int i = bytes.length - 1; i > 0; i--) {
            final byte b = bytes[i];
            if (b == 9 || b == 13 || b == 32) {
                continue;
            }
            return b;
        }
        return 32;
    }

}
